package com.jt.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.jt.mapper.ItemCatMapper;
import com.jt.pojo.ItemCat;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class ItemCatServiceImpl implements ItemCatService {
    @Autowired
    private ItemCatMapper itemCatMapper;

    //1. for循环  2.递归    3.左外连接
    @Override
    public List<ItemCat> findItemCatListByFor(Integer type) {
        //还差一些集合为空时的判断
//        if (type == 1) { //仅查询一级
//            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
//            queryWrapper.eq("parent_id", 0);    //父级为0的就是一级
//            List<ItemCat> firstList = itemCatMapper.selectList(queryWrapper);
//            return firstList;
//        }
//        if (type == 2) { //查询到二级
//            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
//            queryWrapper.eq("parent_id", 0);    //父级为0的就是一级
//            List<ItemCat> firstList = itemCatMapper.selectList(queryWrapper);
//            //根据一级结果查二级
//            for (ItemCat itemCat : firstList) {
//                QueryWrapper<ItemCat> queryWrapper2 = new QueryWrapper<>();
//                queryWrapper2.eq("parent_id", itemCat.getId());    //父级为一级id的就是二级
//                List<ItemCat> secList = itemCatMapper.selectList(queryWrapper2);
//                //将查询到的二级菜单放到一级Children中
//                itemCat.setChildren(secList);
//            }
//            return firstList;
//        }

        QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("parent_id", 0);    //父级为0的就是一级
        List<ItemCat> firstList = itemCatMapper.selectList(queryWrapper);
        if (firstList == null) return null;
        if (type == 1) { //如果type为1，直接返回结果
            return firstList;
        }
            //不是1，就继续查
            for (ItemCat itemCat : firstList) {
                QueryWrapper<ItemCat> queryWrapper2 = new QueryWrapper<>();
                queryWrapper2.eq("parent_id", itemCat.getId());    //父级为一级id的就是二级
                List<ItemCat> secList = itemCatMapper.selectList(queryWrapper2);
                if (secList == null) continue;
                    itemCat.setChildren(secList);
                //如果为3，继续查
                if (type == 3) {
                    //根据二级菜单查三级
                    for (ItemCat cat : secList) {
                        QueryWrapper<ItemCat> queryWrapper3 = new QueryWrapper<>();
                        queryWrapper3.eq("parent_id", cat.getId());    //父级为二级id的就是三级
                        List<ItemCat> thirdList = itemCatMapper.selectList(queryWrapper3);
                        //将查询到的二级菜单放到一级Children中
                        cat.setChildren(thirdList);
                    }
                }
            }
            return firstList;
    }

    /**
     * 要求：仅查询一次数据库
     * 且还需要有父子级联系
     * Map<parentId,List<ItemCat>>
     */
    public Map<Integer,List<ItemCat>> getMap(){
        Map<Integer, List<ItemCat>> map = new HashMap<>();
        //直接查询全部数据
        List<ItemCat> itemCatList =
                itemCatMapper.selectList(null);
        //2.封装Map集合
        //若key存在——获取子级之后add操作
        //若key不存在，将key存储，同时将子级当作第一个元素保存
        for (ItemCat itemCat : itemCatList) {
                if(map.containsKey(itemCat.getParentId())){
                    map.get(itemCat.getParentId()).add(itemCat);
                }else {
                    ArrayList<ItemCat> list = new ArrayList<>();
                    list.add(itemCat);
                    map.put(itemCat.getParentId(),list);
                }
        }
        //key只会有0、一级id、二级id
        //可以根据一级的pid=0查出所有一级分类
        //可以根据二级的pid=xxx查出所有对应的二级分类
        //可以根据三级的pid=xxx查出所有对应的三级分类
        return map;
    }

    /**
     * 整个业务分为两大步骤：
     * 1.获取信息，并将其封装进Map
     * 2.根据Map来建立父子级关系
     * @param type
     * @return
     */
    public List<ItemCat> findItemCatListByMap(Integer type){
        //获取带有联系的父子级分类
        Map<Integer, List<ItemCat>> map = this.getMap();
        //查询一级菜单
        //若分类级别为1，直接返回
        if (type==1) return map.get(0);
        if (type==2) return findSecItemList(map);
        return findThirdItemList(map);

    }

    @Override
    @Transactional
    public void updateStatus(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }

    @Override
    @Transactional      //对方法进行事务控制，防止执行完入库后又出现错误
    public void addItemCat(ItemCat itemCat) {
        //启用
        itemCat.setStatus(true);
        //自动填充功能
        itemCatMapper.insert(itemCat);
//        int a = 1/0;
    }
    /**
     * 实现商品分类删除
     * @param itemCat
     * 实现思路:
     *      根据level 判断层级  之后根据ID删除数据.
     * 删除: 1.手写sql delete from item_cat where id in(100,200...)
     *       2.利用MP机制实现删除
     */
    @Override
    public void deleteItemCat(ItemCat itemCat) {
            //1.判断等级是否是3级
        if (itemCat.getLevel() == 3){
            itemCatMapper.deleteById(itemCat.getId());
        }
        //若是2级
        if (itemCat.getLevel() == 2){
            //先删除3级信息
            QueryWrapper<ItemCat> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("parent_id", itemCat.getId());
            itemCatMapper.delete(queryWrapper);
            //再删自己的
            itemCatMapper.deleteById(itemCat.getId());
        }
        //若是1级
        //可优化
        if (itemCat.getLevel() == 1){
            //先获取2级id
            List<ItemCat> secIds = itemCatMapper.selectList(new QueryWrapper<ItemCat>()
                    .eq("parent_id", itemCat.getId()));
            //删除三级分类
            for (ItemCat secId : secIds) {
                itemCatMapper.delete(new QueryWrapper<ItemCat>()
                .eq("parent_id", secId.getId()));
                //删除自己
                itemCatMapper.deleteById(itemCat.getId());
            }
            itemCatMapper.deleteById(itemCat.getId());

        }
    }

    @Override
    @Transactional
    public void updateItemCat(ItemCat itemCat) {
        itemCatMapper.updateById(itemCat);
    }

    /**
     * 获取封装到三级分类的分类信息
     * @param map
     * @return
     */
    private List<ItemCat> findThirdItemList(Map<Integer, List<ItemCat>> map) {
        //获取封装了二级分类的一级分类
        List<ItemCat> itemList = findSecItemList(map);
        //遍历一级分类中的每一个二级分类
        for (ItemCat firstItem : itemList) {
            //需一级分类下有二级分类才进行进一步操作
            if (firstItem.getChildren() != null){
                //遍历此一级下的二级分类
                for (ItemCat secItem : firstItem.getChildren()) {
                    //将二级分类id作为父id查找map
                    List<ItemCat> thirdList = map.get(secItem.getId());
                    //将三级分类list存入当前二级分类的children中
                    secItem.setChildren(thirdList);
                }
                //当前一级分类下的二级分类已遍历完毕
            }
        }
        //所有一级分类下的二级分类都已遍历完毕
        return itemList;
    }

    /**
     * 获取封装到了二级分类的分类信息
     * @param map
     * @return
     */
    private List<ItemCat> findSecItemList(Map<Integer, List<ItemCat>> map) {
        List<ItemCat> firstList = map.get(0);
        for (ItemCat firstItem : firstList) {
            //二级分类的pid为一级分类的id
            int parent_id = firstItem.getId();
            //直接从map中获取pid为这个id的List对象，既是这个分类id下的子类
            List<ItemCat> secList = map.get(parent_id);
            //如果这个一级分类下没有二级分类，则直接下一次循环
            if (secList == null) continue;
            //将List放入当前一级分类的children
            firstItem.setChildren(secList);
        }
        //最终返回封装了二级分类的list
        return firstList;
    }

}
